package com.ruoyi.quartz.task;

import com.ruoyi.quartz.service.ISysJobService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.StringUtils;

import java.util.*;

/**
 * 定时任务调度测试
 *
 * @author ruoyi
 */
@Component("ryTask")
public class RyTask {
    @Autowired
    private ISysJobService sysJobService;
//    public void ryMultipleParams(String s, Boolean b, Long l, Double d, Integer i)
//    {
//        System.out.println(StringUtils.format("执行多参方法： 字符串类型{}，布尔类型{}，长整型{}，浮点型{}，整形{}", s, b, l, d, i));
//    }
//
//    public void ryParams(String params)
//    {
//        System.out.println("执行有参方法：" + params);
//    }
//
//    public void ryNoParams()
//    {
//
//
//        System.out.println("执行无参方法");
//    }

    public void ryMultipleParams(String s, Boolean b, Long l, Double d, Integer i) {
        System.out.println(StringUtils.format("执行多参方法： 字符串类型{}，布尔类型{}，长整型{}，浮点型{}，整形{}", s, b, l, d, i));
    }

    public void ryParams(String params) {
        System.out.println("执行有参方法：" + params);
    }

    public void ryNoParams() {
        try {
            System.out.println("执行无参方法");
            sysJobService.doSendTask();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 清除历史数据
     */
    public void deleteHistoryData() {
        try {
            System.out.println("清除历史数据开始");
            sysJobService.deleteHistoryData();
            List<Map<String, Object>> tt= sysJobService. deleteStep1();
            if (tt!=null&&tt.size()>0){
                for (int i=0;i<tt.size();i++){
                    sysJobService.deleteStep2(tt.get(i));
                }
            }
            System.out.println("清除历史数据结束");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 每日将  课程激活
     */
    public void resetTodayWxContentData() {
        try {
            System.out.println("重置微信课程开始");
            sysJobService.resetTodayWxContentData();

            System.out.println("重置微信课程结束");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    /**
     * 定时将课程更新至指定时间    因为课程采集的时候  都在在发布时间一年后，因此，可以采取当前时间180天前的  并且状态为1的  表示已经更新过时间了，否则为需要更新的时间。
     * 要点1：获取下次更新的时间 ---需要统计当前180天前  状态为1的  最晚时间的第二天即可
     * 要点2：没个循环15天的数据，取平均值，看每天可以更新几个
     */
    public void resetSendInfo() {
        try {
            System.out.println("重置发送内容时间开始");
          Date date=  sysJobService.getNextGenxinDate();
          List<Long> allupdateId=  sysJobService.get15DaysNeedData();
         List<List<Long>>   needUpdateIds= splitList(allupdateId,15);
             for (int i =0;i<needUpdateIds.size();i++){
                 sysJobService.updateContentDate(needUpdateIds.get(i),date,i);
             }
            System.out.println("重置微信课程结束");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    /**
     * 当  当日没有课程时，将之前课程更新为当前时间
     */
    public void resetHistoryContentToNow() {
        try {
            System.out.println("开始  当日没有课程时，将之前课程更新为当前时间");
            //查询当前是否有课程，
            List<Map<String, Object>> tt= sysJobService. resetHistoryContentToNowStep1();
            if (tt!=null&&tt.size()>0){

            }else{
                //调整之前的课程  改为当前时间
                sysJobService. resetHistoryContentToNowStep2();
            }
            System.out.println("结束  当日没有课程时，将之前课程更新为当前时间");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public List<List<Long>> splitList(List<Long> originalList,int numberOfLists ){
               // 拆分后的集合列表
        List<List<Long>> splitLists = new ArrayList<>();

        // 确保列表是随机的
        Collections.shuffle(originalList);

        // 计算每个集合应该包含的元素数量
        int sizePerList = originalList.size() / numberOfLists;
        int remainingElements = originalList.size() % numberOfLists;

        int start = 0;
        for (int i = 0; i < numberOfLists; i++) {
            int end = start + sizePerList + (remainingElements > 0 ? 1 : 0);
            remainingElements = Math.max(0, remainingElements - 1);
            // 创建子集合
            List<Long> sublist = originalList.subList(start, end);
            splitLists.add(sublist);

            // 更新下一个子集合的开始位置
            start = end;
        }
       return  splitLists;

    }
}
